home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / gtk-2.0 / gtk / gtkwindow.h < prev   
Encoding:
C/C++ Source or Header  |  2006-04-25  |  17.6 KB  |  422 lines
  1. /* GTK - The GIMP Toolkit
  2.  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
  3.  *
  4.  * This library is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU Lesser General Public
  6.  * License as published by the Free Software Foundation; either
  7.  * version 2 of the License, or (at your option) any later version.
  8.  *
  9.  * This library is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12.  * Lesser General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU Lesser General Public
  15.  * License along with this library; if not, write to the
  16.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17.  * Boston, MA 02111-1307, USA.
  18.  */
  19.  
  20. /*
  21.  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22.  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23.  * files for a list of changes.  These files are distributed with
  24.  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
  25.  */
  26.  
  27. #ifndef __GTK_WINDOW_H__
  28. #define __GTK_WINDOW_H__
  29.  
  30.  
  31. #include <gdk/gdk.h>
  32. #include <gtk/gtkaccelgroup.h>
  33. #include <gtk/gtkbin.h>
  34. #include <gtk/gtkenums.h>
  35. #include <gtk/gtkwidget.h>
  36.  
  37. G_BEGIN_DECLS
  38.  
  39. #define GTK_TYPE_WINDOW            (gtk_window_get_type ())
  40. #define GTK_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WINDOW, GtkWindow))
  41. #define GTK_WINDOW_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WINDOW, GtkWindowClass))
  42. #define GTK_IS_WINDOW(obj)        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WINDOW))
  43. #define GTK_IS_WINDOW_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WINDOW))
  44. #define GTK_WINDOW_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WINDOW, GtkWindowClass))
  45.  
  46.  
  47. typedef struct _GtkWindow             GtkWindow;
  48. typedef struct _GtkWindowClass        GtkWindowClass;
  49. typedef struct _GtkWindowGeometryInfo GtkWindowGeometryInfo;
  50. typedef struct _GtkWindowGroup        GtkWindowGroup;
  51. typedef struct _GtkWindowGroupClass   GtkWindowGroupClass;
  52.  
  53. struct _GtkWindow
  54. {
  55.   GtkBin bin;
  56.  
  57.   gchar *title;
  58.   gchar *wmclass_name;
  59.   gchar *wmclass_class;
  60.   gchar *wm_role;
  61.  
  62.   GtkWidget *focus_widget;
  63.   GtkWidget *default_widget;
  64.   GtkWindow *transient_parent;
  65.   GtkWindowGeometryInfo *geometry_info;
  66.   GdkWindow *frame;
  67.   GtkWindowGroup *group;
  68.  
  69.   guint16 configure_request_count;
  70.   guint allow_shrink : 1;
  71.   guint allow_grow : 1;
  72.   guint configure_notify_received : 1;
  73.   /* The following flags are initially TRUE (before a window is mapped).
  74.    * They cause us to compute a configure request that involves
  75.    * default-only parameters. Once mapped, we set them to FALSE.
  76.    * Then we set them to TRUE again on unmap (for position)
  77.    * and on unrealize (for size).
  78.    */
  79.   guint need_default_position : 1;
  80.   guint need_default_size : 1;
  81.   guint position : 3;
  82.   guint type : 4; /* GtkWindowType */ 
  83.   guint has_user_ref_count : 1;
  84.   guint has_focus : 1;
  85.  
  86.   guint modal : 1;
  87.   guint destroy_with_parent : 1;
  88.   
  89.   guint has_frame : 1;
  90.  
  91.   /* gtk_window_iconify() called before realization */
  92.   guint iconify_initially : 1;
  93.   guint stick_initially : 1;
  94.   guint maximize_initially : 1;
  95.   guint decorated : 1;
  96.   
  97.   guint type_hint : 3; /* GdkWindowTypeHint */ 
  98.   guint gravity : 5; /* GdkGravity */
  99.  
  100.   guint is_active : 1;
  101.   guint has_toplevel_focus : 1;
  102.   
  103.   guint frame_left;
  104.   guint frame_top;
  105.   guint frame_right;
  106.   guint frame_bottom;
  107.  
  108.   guint keys_changed_handler;
  109.   
  110.   GdkModifierType mnemonic_modifier;
  111.   GdkScreen      *screen;
  112. };
  113.  
  114. struct _GtkWindowClass
  115. {
  116.   GtkBinClass parent_class;
  117.  
  118.   void     (* set_focus)   (GtkWindow *window,
  119.                 GtkWidget *focus);
  120.   gboolean (* frame_event) (GtkWindow *window,
  121.                 GdkEvent  *event);
  122.  
  123.   /* G_SIGNAL_ACTION signals for keybindings */
  124.  
  125.   void     (* activate_focus)          (GtkWindow       *window);
  126.   void     (* activate_default)        (GtkWindow       *window);
  127.   void     (* move_focus)              (GtkWindow       *window,
  128.                                         GtkDirectionType direction);
  129.   
  130.   void       (*keys_changed)           (GtkWindow    *window);
  131.   
  132.   /* Padding for future expansion */
  133.   void (*_gtk_reserved1) (void);
  134.   void (*_gtk_reserved2) (void);
  135.   void (*_gtk_reserved3) (void);
  136.   void (*_gtk_reserved4) (void);
  137. };
  138.  
  139. #define GTK_TYPE_WINDOW_GROUP             (gtk_window_group_get_type ())
  140. #define GTK_WINDOW_GROUP(object)          (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_WINDOW_GROUP, GtkWindowGroup))
  141. #define GTK_WINDOW_GROUP_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WINDOW_GROUP, GtkWindowGroupClass))
  142. #define GTK_IS_WINDOW_GROUP(object)       (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_WINDOW_GROUP))
  143. #define GTK_IS_WINDOW_GROUP_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WINDOW_GROUP))
  144. #define GTK_WINDOW_GROUP_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WINDOW_GROUP, GtkWindowGroupClass))
  145.  
  146. struct _GtkWindowGroup
  147. {
  148.   GObject parent_instance;
  149.  
  150.   GSList *grabs;
  151. };
  152.  
  153. struct _GtkWindowGroupClass
  154. {
  155.   GObjectClass parent_class;
  156.  
  157.   /* Padding for future expansion */
  158.   void (*_gtk_reserved1) (void);
  159.   void (*_gtk_reserved2) (void);
  160.   void (*_gtk_reserved3) (void);
  161.   void (*_gtk_reserved4) (void);
  162. };
  163.  
  164. #ifdef G_OS_WIN32
  165. /* Reserve old names for DLL ABI backward compatibility */
  166. #define gtk_window_set_icon_from_file gtk_window_set_icon_from_file_utf8
  167. #define gtk_window_set_default_icon_from_file gtk_window_set_default_icon_from_file_utf8
  168. #endif
  169.  
  170. GType      gtk_window_get_type                 (void) G_GNUC_CONST;
  171. GtkWidget* gtk_window_new                      (GtkWindowType        type);
  172. void       gtk_window_set_title                (GtkWindow           *window,
  173.                         const gchar         *title);
  174. G_CONST_RETURN gchar *gtk_window_get_title     (GtkWindow           *window);
  175. void       gtk_window_set_wmclass              (GtkWindow           *window,
  176.                         const gchar         *wmclass_name,
  177.                         const gchar         *wmclass_class);
  178. void       gtk_window_set_role                 (GtkWindow           *window,
  179.                                                 const gchar         *role);
  180. G_CONST_RETURN gchar *gtk_window_get_role      (GtkWindow           *window);
  181. void       gtk_window_add_accel_group          (GtkWindow           *window,
  182.                         GtkAccelGroup        *accel_group);
  183. void       gtk_window_remove_accel_group       (GtkWindow           *window,
  184.                         GtkAccelGroup        *accel_group);
  185. void       gtk_window_set_position             (GtkWindow           *window,
  186.                         GtkWindowPosition    position);
  187. gboolean   gtk_window_activate_focus           (GtkWindow           *window);
  188. void       gtk_window_set_focus                (GtkWindow           *window,
  189.                         GtkWidget           *focus);
  190. GtkWidget *gtk_window_get_focus                (GtkWindow           *window);
  191. void       gtk_window_set_default              (GtkWindow           *window,
  192.                         GtkWidget           *default_widget);
  193. gboolean   gtk_window_activate_default           (GtkWindow           *window);
  194.  
  195. void       gtk_window_set_transient_for        (GtkWindow           *window, 
  196.                         GtkWindow           *parent);
  197. GtkWindow *gtk_window_get_transient_for        (GtkWindow           *window);
  198. void       gtk_window_set_type_hint            (GtkWindow           *window, 
  199.                         GdkWindowTypeHint    hint);
  200. GdkWindowTypeHint gtk_window_get_type_hint     (GtkWindow           *window);
  201. void       gtk_window_set_skip_taskbar_hint    (GtkWindow           *window,
  202.                                                 gboolean             setting);
  203. gboolean   gtk_window_get_skip_taskbar_hint    (GtkWindow           *window);
  204. void       gtk_window_set_skip_pager_hint      (GtkWindow           *window,
  205.                                                 gboolean             setting);
  206. gboolean   gtk_window_get_skip_pager_hint      (GtkWindow           *window);
  207. void       gtk_window_set_urgency_hint         (GtkWindow           *window,
  208.                                                 gboolean             setting);
  209. gboolean   gtk_window_get_urgency_hint         (GtkWindow           *window);
  210. void       gtk_window_set_accept_focus         (GtkWindow           *window,
  211.                                                 gboolean             setting);
  212. gboolean   gtk_window_get_accept_focus         (GtkWindow           *window);
  213. void       gtk_window_set_focus_on_map         (GtkWindow           *window,
  214.                                                 gboolean             setting);
  215. gboolean   gtk_window_get_focus_on_map         (GtkWindow           *window);
  216. void       gtk_window_set_destroy_with_parent  (GtkWindow           *window,
  217.                                                 gboolean             setting);
  218. gboolean   gtk_window_get_destroy_with_parent  (GtkWindow           *window);
  219.  
  220. void       gtk_window_set_resizable            (GtkWindow           *window,
  221.                                                 gboolean             resizable);
  222. gboolean   gtk_window_get_resizable            (GtkWindow           *window);
  223.  
  224. void       gtk_window_set_gravity              (GtkWindow           *window,
  225.                                                 GdkGravity           gravity);
  226. GdkGravity gtk_window_get_gravity              (GtkWindow           *window);
  227.  
  228.  
  229. void       gtk_window_set_geometry_hints       (GtkWindow           *window,
  230.                         GtkWidget           *geometry_widget,
  231.                         GdkGeometry         *geometry,
  232.                         GdkWindowHints       geom_mask);
  233.  
  234. void       gtk_window_set_screen           (GtkWindow        *window,
  235.                         GdkScreen        *screen);
  236. GdkScreen* gtk_window_get_screen           (GtkWindow        *window);
  237.  
  238. gboolean   gtk_window_is_active                (GtkWindow           *window);
  239. gboolean   gtk_window_has_toplevel_focus       (GtkWindow           *window);
  240.  
  241.  
  242.  
  243. /* gtk_window_set_has_frame () must be called before realizing the window_*/
  244. void       gtk_window_set_has_frame            (GtkWindow *window, 
  245.                         gboolean   setting);
  246. gboolean   gtk_window_get_has_frame            (GtkWindow *window);
  247. void       gtk_window_set_frame_dimensions     (GtkWindow *window, 
  248.                         gint       left,
  249.                         gint       top,
  250.                         gint       right,
  251.                         gint       bottom);
  252. void       gtk_window_get_frame_dimensions     (GtkWindow *window, 
  253.                         gint      *left,
  254.                         gint      *top,
  255.                         gint      *right,
  256.                         gint      *bottom);
  257. void       gtk_window_set_decorated            (GtkWindow *window,
  258.                                                 gboolean   setting);
  259. gboolean   gtk_window_get_decorated            (GtkWindow *window);
  260.  
  261. void       gtk_window_set_icon_list                (GtkWindow  *window,
  262.                                                     GList      *list);
  263. GList*     gtk_window_get_icon_list                (GtkWindow  *window);
  264. void       gtk_window_set_icon                     (GtkWindow  *window,
  265.                                                     GdkPixbuf  *icon);
  266. void       gtk_window_set_icon_name                (GtkWindow   *window,
  267.                             const gchar *name);
  268. gboolean   gtk_window_set_icon_from_file           (GtkWindow   *window,
  269.                             const gchar *filename,
  270.                             GError     **err);
  271. GdkPixbuf* gtk_window_get_icon                     (GtkWindow  *window);
  272. G_CONST_RETURN 
  273. gchar     *gtk_window_get_icon_name                (GtkWindow  *window);
  274. void       gtk_window_set_default_icon_list        (GList      *list);
  275. GList*     gtk_window_get_default_icon_list        (void);
  276. void       gtk_window_set_default_icon             (GdkPixbuf  *icon);
  277. void       gtk_window_set_default_icon_name        (const gchar *name);
  278. gboolean   gtk_window_set_default_icon_from_file   (const gchar *filename,
  279.                             GError     **err);
  280.  
  281. void       gtk_window_set_auto_startup_notification (gboolean setting);
  282.  
  283. /* If window is set modal, input will be grabbed when show and released when hide */
  284. void       gtk_window_set_modal      (GtkWindow *window,
  285.                       gboolean   modal);
  286. gboolean   gtk_window_get_modal      (GtkWindow *window);
  287. GList*     gtk_window_list_toplevels (void);
  288.  
  289. void     gtk_window_add_mnemonic          (GtkWindow       *window,
  290.                        guint            keyval,
  291.                        GtkWidget       *target);
  292. void     gtk_window_remove_mnemonic       (GtkWindow       *window,
  293.                        guint            keyval,
  294.                        GtkWidget       *target);
  295. gboolean gtk_window_mnemonic_activate     (GtkWindow       *window,
  296.                        guint            keyval,
  297.                        GdkModifierType  modifier);
  298. void     gtk_window_set_mnemonic_modifier (GtkWindow       *window,
  299.                        GdkModifierType  modifier);
  300. GdkModifierType gtk_window_get_mnemonic_modifier (GtkWindow *window);
  301.  
  302. gboolean gtk_window_activate_key          (GtkWindow        *window,
  303.                        GdkEventKey      *event);
  304. gboolean gtk_window_propagate_key_event   (GtkWindow        *window,
  305.                        GdkEventKey      *event);
  306.  
  307. void     gtk_window_present            (GtkWindow *window);
  308. void     gtk_window_present_with_time  (GtkWindow *window,
  309.                         guint32    timestamp);
  310. void     gtk_window_iconify       (GtkWindow *window);
  311. void     gtk_window_deiconify     (GtkWindow *window);
  312. void     gtk_window_stick         (GtkWindow *window);
  313. void     gtk_window_unstick       (GtkWindow *window);
  314. void     gtk_window_maximize      (GtkWindow *window);
  315. void     gtk_window_unmaximize    (GtkWindow *window);
  316. void     gtk_window_fullscreen    (GtkWindow *window);
  317. void     gtk_window_unfullscreen  (GtkWindow *window);
  318. void     gtk_window_set_keep_above    (GtkWindow *window, gboolean setting);
  319. void     gtk_window_set_keep_below    (GtkWindow *window, gboolean setting);
  320.  
  321. void gtk_window_begin_resize_drag (GtkWindow     *window,
  322.                                    GdkWindowEdge  edge,
  323.                                    gint           button,
  324.                                    gint           root_x,
  325.                                    gint           root_y,
  326.                                    guint32        timestamp);
  327. void gtk_window_begin_move_drag   (GtkWindow     *window,
  328.                                    gint           button,
  329.                                    gint           root_x,
  330.                                    gint           root_y,
  331.                                    guint32        timestamp);
  332.  
  333. #ifndef GTK_DISABLE_DEPRECATED
  334. void       gtk_window_set_policy               (GtkWindow           *window,
  335.                         gint                 allow_shrink,
  336.                         gint                 allow_grow,
  337.                         gint                 auto_shrink);
  338. #define    gtk_window_position            gtk_window_set_position
  339. #endif /* GTK_DISABLE_DEPRECATED */
  340.  
  341. /* Set initial default size of the window (does not constrain user
  342.  * resize operations)
  343.  */
  344. void     gtk_window_set_default_size (GtkWindow   *window,
  345.                                       gint         width,
  346.                                       gint         height);
  347. void     gtk_window_get_default_size (GtkWindow   *window,
  348.                                       gint        *width,
  349.                                       gint        *height);
  350. void     gtk_window_resize           (GtkWindow   *window,
  351.                                       gint         width,
  352.                                       gint         height);
  353. void     gtk_window_get_size         (GtkWindow   *window,
  354.                                       gint        *width,
  355.                                       gint        *height);
  356. void     gtk_window_move             (GtkWindow   *window,
  357.                                       gint         x,
  358.                                       gint         y);
  359. void     gtk_window_get_position     (GtkWindow   *window,
  360.                                       gint        *root_x,
  361.                                       gint        *root_y);
  362. gboolean gtk_window_parse_geometry   (GtkWindow   *window,
  363.                                       const gchar *geometry);
  364.  
  365. /* Ignore this unless you are writing a GUI builder */
  366. void     gtk_window_reshow_with_initial_size (GtkWindow *window);
  367.  
  368. /* Window groups
  369.  */
  370. GType            gtk_window_group_get_type      (void) G_GNUC_CONST;
  371.  
  372. GtkWindowGroup * gtk_window_group_new           (void);
  373. void             gtk_window_group_add_window    (GtkWindowGroup     *window_group,
  374.                          GtkWindow          *window);
  375. void             gtk_window_group_remove_window (GtkWindowGroup     *window_group,
  376.                              GtkWindow          *window);
  377.  
  378. /* --- internal functions --- */
  379. void            _gtk_window_internal_set_focus (GtkWindow *window,
  380.                         GtkWidget *focus);
  381. void            gtk_window_remove_embedded_xid (GtkWindow *window,
  382.                         guint      xid);
  383. void            gtk_window_add_embedded_xid    (GtkWindow *window,
  384.                         guint      xid);
  385. void            _gtk_window_reposition         (GtkWindow *window,
  386.                         gint       x,
  387.                         gint       y);
  388. void            _gtk_window_constrain_size     (GtkWindow *window,
  389.                         gint       width,
  390.                         gint       height,
  391.                         gint      *new_width,
  392.                         gint      *new_height);
  393. GtkWindowGroup *_gtk_window_get_group          (GtkWindow *window);
  394. GtkWidget      *_gtk_window_group_get_current_grab (GtkWindowGroup *window_group);
  395.  
  396. void            _gtk_window_set_has_toplevel_focus (GtkWindow *window,
  397.                             gboolean   has_toplevel_focus);
  398. void            _gtk_window_unset_focus_and_default (GtkWindow *window,
  399.                              GtkWidget *widget);
  400.  
  401. void            _gtk_window_set_is_active          (GtkWindow *window,
  402.                             gboolean   is_active);
  403.  
  404. typedef void (*GtkWindowKeysForeachFunc) (GtkWindow      *window,
  405.                       guint           keyval,
  406.                       GdkModifierType modifiers,
  407.                       gboolean        is_mnemonic,
  408.                       gpointer        data);
  409.  
  410. void _gtk_window_keys_foreach (GtkWindow               *window,
  411.                    GtkWindowKeysForeachFunc func,
  412.                    gpointer                 func_data);
  413.  
  414. /* --- internal (GtkAcceleratable) --- */
  415. gboolean    _gtk_window_query_nonaccels    (GtkWindow    *window,
  416.                          guint         accel_key,
  417.                          GdkModifierType accel_mods);
  418.  
  419. G_END_DECLS
  420.  
  421. #endif /* __GTK_WINDOW_H__ */
  422.